package com.SRMS.service;

import com.SRMS.common.Message;
import com.SRMS.common.MessageType;
import com.SRMS.common.User;
import com.SRMS.domain.*;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.util.List;

/**
 * @author Albert
 * @version 1.0
 * @date 2023/12/24-0:47
 * @describe 界面服务
 */
public class UserClientService {
    private static User u = new User();
    private static Socket socket = null;

    /**
     * 管理员查看所有的自习室使用记录
     *
     * @return
     */
    public static List<HistoryOfRoomUsage> historyOfRoomUsageList() {
        //发送一个Message，类型GET_HISTORY_OF_ROOM_USAGE
        Message message = new Message();
        message.setMesType(MessageType.GET_HISTORY_OF_ROOM_USAGE);
        message.setSender(u.getId());

        //发给服务器，应该得到当前线程的Socket对应的ObjectOutputStream对象
        try {
            //通过userId得到对应的线程，从线程里面获取socket对象，再从Socket对象里面获取OutputStream对象
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            //如果服务器没有发送Message对象，线程会阻塞在这里
            message = (Message) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        if (message.getMesType().equals(MessageType.RET_HISTORY_OF_ROOM_USAGE)) {
            return message.getHistoryOfRoomUsages();
        }
        return null;
    }

    /**
     * 管理员请求自习室列表
     *
     * @return 自习室列表
     */
    public static List<StudyRoom> studyRoomListForAdministrator() {
        //发送一个Message，类型GET_STUDY_ROOM_LIST_FOR_ADMINISTRATOR
        Message message = new Message();
        message.setMesType(MessageType.GET_STUDY_ROOM_LIST_FOR_ADMINISTRATOR);
        message.setSender(u.getId());

        //发给服务器，应该得到当前线程的Socket对应的ObjectOutputStream对象
        try {
            //通过userId得到对应的线程，从线程里面获取socket对象，再从Socket对象里面获取OutputStream对象
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            //如果服务器没有发送Message对象，线程会阻塞在这里
            message = (Message) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        if (message.getMesType().equals(MessageType.RET_STUDY_ROOM_LIST_FOR_ADMINISTRATOR)) {
            return message.getStudyRoomList();
        }
        return null;
    }

    /**
     * 管理员删除自习室
     *
     * @param studyRoomId 需要删除的自习室编号
     * @return 删除结果（true/false）
     */
    public static boolean deleteStudyRoomById(String studyRoomId) {
        //发送一个Message，类型DELETE_STUDY_ROOM
        Message message = new Message();
        message.setMesType(MessageType.DELETE_STUDY_ROOM);
        message.setSender(u.getId());
        message.setStudyRoomId(studyRoomId);

        //发给服务器，应该得到当前线程的Socket对应的ObjectOutputStream对象
        try {
            //通过userId得到对应的线程，从线程里面获取socket对象，再从Socket对象里面获取OutputStream对象
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            //如果服务器没有发送Message对象，线程会阻塞在这里
            message = (Message) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        if (message.getMesType().equals(MessageType.RET_RESULT_OF_DELETE_STUDY_ROOM)) {
            return message.isResult();
        }
        return false;
    }

    /**
     * 管理员修改自习室信息
     *
     * @param studyRoom 需要进行修改的自习室对象
     * @return 修改结果（true/false）
     */
    public static boolean updateStudyRoom(StudyRoom studyRoom) {
        //发送一个Message，类型UPDATE_STUDY_ROOM
        Message message = new Message();
        message.setMesType(MessageType.UPDATE_STUDY_ROOM);
        message.setSender(u.getId());
        message.setStudyRoom(studyRoom);

        //发给服务器，应该得到当前线程的Socket对应的ObjectOutputStream对象
        try {
            //通过userId得到对应的线程，从线程里面获取socket对象，再从Socket对象里面获取OutputStream对象
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            //如果服务器没有发送Message对象，线程会阻塞在这里
            message = (Message) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        if (message.getMesType().equals(MessageType.RET_RESULT_OF_UPDATE_STUDY_ROOM)) {
            return message.isResult();
        }
        return false;
    }

    /**
     * 管理员添加自习室
     *
     * @param studyRoom 需要添加的自习室对象
     * @return 添加结果（true/false）
     */
    public static boolean addStudyRoom(StudyRoom studyRoom) {
        //发送一个Message，类型ADD_STUDY_ROOM
        Message message = new Message();
        message.setMesType(MessageType.ADD_STUDY_ROOM);
        message.setSender(u.getId());
        message.setStudyRoom(studyRoom);

        //发给服务器，应该得到当前线程的Socket对应的ObjectOutputStream对象
        try {
            //通过userId得到对应的线程，从线程里面获取socket对象，再从Socket对象里面获取OutputStream对象
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            //如果服务器没有发送Message对象，线程会阻塞在这里
            message = (Message) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        if (message.getMesType().equals(MessageType.RET_RESULT_OF_ADD_STUDY_ROOM)) {
            return message.isResult();
        }
        return false;
    }

    /**
     * 管理员查询指定的自习室
     *
     * @param studyRoomId 自习室编号
     * @return 自习室对象
     */
    public static StudyRoom getStudyRoomById(String studyRoomId) {
        //发送一个Message，类型GET_STUDY_ROOM_FOR_ADMINISTRATOR
        Message message = new Message();
        message.setMesType(MessageType.GET_STUDY_ROOM_FOR_ADMINISTRATOR);
        message.setSender(u.getId());
        message.setStudyRoomId(studyRoomId);

        //发给服务器，应该得到当前线程的Socket对应的ObjectOutputStream对象
        try {
            //通过userId得到对应的线程，从线程里面获取socket对象，再从Socket对象里面获取OutputStream对象
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            //如果服务器没有发送Message对象，线程会阻塞在这里
            message = (Message) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        if (message.getMesType().equals(MessageType.RET_STUDY_ROOM_FOR_ADMINISTRATOR)) {
            return message.getStudyRoom();
        }
        return null;
    }

    /**
     * 管理员查询所有学生
     *
     * @return 学生列表
     */
    public static List<Student> studentList() {
        //发送一个Message，类型GET_STUDENT_LIST
        Message message = new Message();
        message.setMesType(MessageType.GET_STUDENT_LIST);
        message.setSender(u.getId());

        //发给服务器，应该得到当前线程的Socket对应的ObjectOutputStream对象
        try {
            //通过userId得到对应的线程，从线程里面获取socket对象，再从Socket对象里面获取OutputStream对象
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            //如果服务器没有发送Message对象，线程会阻塞在这里
            message = (Message) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        if (message.getMesType().equals(MessageType.RET_STUDENT_LIST)) {
            return message.getStudents();
        }
        return null;
    }

    /**
     * 管理员删除学生
     *
     * @param studentId 学号
     * @return 删除结果（true/false）
     */
    public static boolean deleteStudentById(String studentId) {
        //发送一个Message，类型DELETE_STUDENT
        Message message = new Message();
        message.setMesType(MessageType.DELETE_STUDENT);
        message.setSender(u.getId());
        message.setStudentId(studentId);

        //发给服务器，应该得到当前线程的Socket对应的ObjectOutputStream对象
        try {
            //通过userId得到对应的线程，从线程里面获取socket对象，再从Socket对象里面获取OutputStream对象
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            //如果服务器没有发送Message对象，线程会阻塞在这里
            message = (Message) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        if (message.getMesType().equals(MessageType.RET_RESULT_OF_DELETE_STUDENT)) {
            return message.isResult();
        }
        return false;
    }

    /**
     * 管理员更新学生信息
     *
     * @param student 需要进行更新的学生对象
     * @return 更新结果（true/false）
     */
    public static boolean updateStudent(Student student) {
        //发送一个Message，类型UPDATE_STUDENT
        Message message = new Message();
        message.setMesType(MessageType.UPDATE_STUDENT);
        message.setSender(u.getId());
        message.setStudent(student);

        //发给服务器，应该得到当前线程的Socket对应的ObjectOutputStream对象
        try {
            //通过userId得到对应的线程，从线程里面获取socket对象，再从Socket对象里面获取OutputStream对象
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            //如果服务器没有发送Message对象，线程会阻塞在这里
            message = (Message) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        if (message.getMesType().equals(MessageType.RET_RESULT_OF_UPDATE_STUDENT)) {
            return message.isResult();
        }
        return false;
    }

    /**
     * 管理员添加学生
     *
     * @param student 需要添加的学生对象
     * @return 添加结果（true/false）
     */
    public static boolean addStudent(Student student) {
        //发送一个Message，类型ADD_STUDENT
        Message message = new Message();
        message.setMesType(MessageType.ADD_STUDENT);
        message.setSender(u.getId());
        message.setStudent(student);

        //发给服务器，应该得到当前线程的Socket对应的ObjectOutputStream对象
        try {
            //通过userId得到对应的线程，从线程里面获取socket对象，再从Socket对象里面获取OutputStream对象
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            //如果服务器没有发送Message对象，线程会阻塞在这里
            message = (Message) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        if (message.getMesType().equals(MessageType.RET_RESULT_OF_ADD_STUDENT)) {
            return message.isResult();
        }
        return false;
    }

    /**
     * 根据学号来查找指定学生
     *
     * @param studentId 学号
     * @return 学生对象
     */
    public static Student getStudentById(String studentId) {
        //发送一个Message，类型GET_STUDENT
        Message message = new Message();
        message.setMesType(MessageType.GET_STUDENT);
        message.setSender(u.getId());
        message.setStudentId(studentId);

        //发给服务器，应该得到当前线程的Socket对应的ObjectOutputStream对象
        try {
            //通过userId得到对应的线程，从线程里面获取socket对象，再从Socket对象里面获取OutputStream对象
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            //如果服务器没有发送Message对象，线程会阻塞在这里
            message = (Message) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        if (message.getMesType().equals(MessageType.RET_STUDENT)) {
            return message.getStudent();
        }
        return null;
    }

    /**
     * 管理员查询所有的撤销记录
     *
     * @return 撤销记录列表
     */
    public static List<RevokeRecordForAdmin> revokeRecordForAdminList() {
        //发送一个Message，类型GET_REVOKE_RECORD_LIST
        Message message = new Message();
        message.setMesType(MessageType.GET_REVOKE_RECORD_LIST);
        message.setSender(u.getId());

        //发给服务器，应该得到当前线程的Socket对应的ObjectOutputStream对象
        try {
            //通过userId得到对应的线程，从线程里面获取socket对象，再从Socket对象里面获取OutputStream对象
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            //如果服务器没有发送Message对象，线程会阻塞在这里
            message = (Message) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        if (message.getMesType().equals(MessageType.RET_REVOKE_RECORD_LIST)) {
            return message.getRevokeRecordForAdmins();
        }
        return null;
    }

    /**
     * 管理员撤销学生的使用权
     *
     * @param studentId    学生学号
     * @param revokeReason 撤销原因
     * @return 撤销结果(true / false)
     */
    public static boolean revokeRightByStudentId(String studentId, String revokeReason) {
        //发送一个Message，类型REVOKE_RIGHT
        Message message = new Message();
        message.setMesType(MessageType.REVOKE_RIGHT);
        message.setSender(u.getId());
        message.setRevokeReason(revokeReason);
        message.setStudentId(studentId);

        //发给服务器，应该得到当前线程的Socket对应的ObjectOutputStream对象
        try {
            //通过userId得到对应的线程，从线程里面获取socket对象，再从Socket对象里面获取OutputStream对象
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            //如果服务器没有发送Message对象，线程会阻塞在这里
            message = (Message) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        if (message.getMesType().equals(MessageType.RET_RESULT_REVOKE_RIGHT)) {
            return message.isResult();
        }
        return false;
    }

    /**
     * 管理员查询该学生拥有的使用权
     *
     * @param studentId 需要查询的学生学号
     * @return 使用权对象
     */
    public static RightToUseStudyRoom getRightByStuIdForAdministrator(String studentId) {
        //发送一个Message，类型GET_RIGHT_FOR_ADMINISTRATOR
        Message message = new Message();
        message.setMesType(MessageType.GET_RIGHT_FOR_ADMINISTRATOR);
        message.setSender(u.getId());
        message.setStudentId(studentId);

        //发给服务器，应该得到当前线程的Socket对应的ObjectOutputStream对象
        try {
            //通过userId得到对应的线程，从线程里面获取socket对象，再从Socket对象里面获取OutputStream对象
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            //如果服务器没有发送Message对象，线程会阻塞在这里
            message = (Message) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        if (message.getMesType().equals(MessageType.RET_RIGHT_FOR_ADMINISTRATOR)) {
            return message.getRightToUseStudyRoom();
        }
        return null;
    }

    /**
     * 管理员查询所有的自习室使用权信息
     *
     * @return
     */
    public static List<RightRecord> rightList() {
        //发送一个Message，类型GET_RIGHT_RECORD_LIST
        Message message = new Message();
        message.setMesType(MessageType.GET_RIGHT_RECORD_LIST);
        message.setSender(u.getId());

        //发给服务器，应该得到当前线程的Socket对应的ObjectOutputStream对象
        try {
            //通过userId得到对应的线程，从线程里面获取socket对象，再从Socket对象里面获取OutputStream对象
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            //如果服务器没有发送Message对象，线程会阻塞在这里
            message = (Message) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        if (message.getMesType().equals(MessageType.RET_RIGHT_RECORD_LIST)) {
            return message.getRightRecords();
        }
        return null;
    }

    /**
     * 学生查询自己的自习室历史使用记录
     *
     * @return 历史使用记录列表
     */
    public static List<HistoryForStudent> getHistoryForStudentByStudentId() {
        //发送一个Message，类型GET_HISTORY_FOR_STUDENT
        Message message = new Message();
        message.setMesType(MessageType.GET_HISTORY_FOR_STUDENT);
        message.setSender(u.getId());

        //发给服务器，应该得到当前线程的Socket对应的ObjectOutputStream对象
        try {
            //通过userId得到对应的线程，从线程里面获取socket对象，再从Socket对象里面获取OutputStream对象
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            //如果服务器没有发送Message对象，线程会阻塞在这里
            message = (Message) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        if (message.getMesType().equals(MessageType.RET_HISTORY_FOR_STUDENT)) {
            return message.getHistoryForStudentList();
        }
        return null;
    }

    /**
     * 学生归还自习室使用权
     *
     * @param rightToUseStudyRoom 自习室使用权
     * @return 归还结果
     */
    public static boolean returnRight(RightToUseStudyRoom rightToUseStudyRoom) {
        //发送一个Message，类型RETURN_RIGHT
        Message message = new Message();
        message.setMesType(MessageType.RETURN_RIGHT);
        message.setSender(u.getId());
        message.setRightToUseStudyRoom(rightToUseStudyRoom);

        //发给服务器，应该得到当前线程的Socket对应的ObjectOutputStream对象
        try {
            //通过userId得到对应的线程，从线程里面获取socket对象，再从Socket对象里面获取OutputStream对象
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            //如果服务器没有发送Message对象，线程会阻塞在这里
            message = (Message) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        if (message.getMesType().equals(MessageType.RET_RESULT_OF_RETURN_RIGHT)) {
            return message.isResult();
        }
        return false;
    }

    /**
     * 学生查询拥有使用权的自习室信息
     *
     * @return 学生可查看的自习室信息
     */
    public static RoomForStudent getAppliedStudyRoom() {
        //发送一个Message，类型GET_APPLIED_STUDY_ROOM
        Message message = new Message();
        message.setMesType(MessageType.GET_APPLIED_STUDY_ROOM);
        message.setSender(u.getId());

        //发给服务器，应该得到当前线程的Socket对应的ObjectOutputStream对象
        try {
            //通过userId得到对应的线程，从线程里面获取socket对象，再从Socket对象里面获取OutputStream对象
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            //如果服务器没有发送Message对象，线程会阻塞在这里
            message = (Message) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        if (message.getMesType().equals(MessageType.RET_APPLIED_STUDY_ROOM)) {
            return message.getRoomForStudent();
        }
        return null;
    }

    /**
     * 学生发送申请自习室请求
     *
     * @param remainingSeats 申请成功后该自习室剩余座位数
     * @param studyRoomId    需要申请的自习室的编号
     * @return 申请结果
     */
    public static boolean applyStudyRoom(int remainingSeats, String studyRoomId) {
        //发送一个Message，类型APPLY_STUDY_ROOM
        Message message = new Message();
        message.setMesType(MessageType.APPLY_STUDY_ROOM);
        message.setSender(u.getId());
        message.setRemainingSeats(remainingSeats);
        message.setStudyRoomId(studyRoomId);

        //发给服务器，应该得到当前线程的Socket对应的ObjectOutputStream对象
        try {
            //通过userId得到对应的线程，从线程里面获取socket对象，再从Socket对象里面获取OutputStream对象
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            //如果服务器没有发送Message对象，线程会阻塞在这里
            message = (Message) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        if (message.getMesType().equals(MessageType.RET_RESULT_OF_APPLY_STUDY_ROOM)) {
            return message.isResult();
        }
        return false;
    }

    /**
     * 学生查询指定编号的自习室
     *
     * @param studyRoomId 自习室编号
     * @return 自习室对象
     */
    public static StudyRoom getStudyRoomByIdForStudent(String studyRoomId) {
        //发送一个Message，类型GET_STUDY_ROOM_FOR_STUDENT
        Message message = new Message();
        message.setMesType(MessageType.GET_STUDY_ROOM_FOR_STUDENT);
        message.setSender(u.getId());
        message.setStudyRoomId(studyRoomId);

        //发给服务器，应该得到当前线程的Socket对应的ObjectOutputStream对象
        try {
            //通过userId得到对应的线程，从线程里面获取socket对象，再从Socket对象里面获取OutputStream对象
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            //如果服务器没有发送Message对象，线程会阻塞在这里
            message = (Message) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        if (message.getMesType().equals(MessageType.RET_STUDY_ROOM_FOR_STUDENT)) {
            return message.getStudyRoom();
        }
        return null;
    }

    /**
     * 学生查询拥有的使用权
     *
     * @return 使用权对象
     */
    public static RightToUseStudyRoom getRightByStuIdForStudent() {
        //发送一个Message，类型GET_RIGHT_FOR_STUDENT
        Message message = new Message();
        message.setMesType(MessageType.GET_RIGHT_FOR_STUDENT);
        message.setSender(u.getId());

        //发给服务器，应该得到当前线程的Socket对应的ObjectOutputStream对象
        try {
            //通过userId得到对应的线程，从线程里面获取socket对象，再从Socket对象里面获取OutputStream对象
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            //如果服务器没有发送Message对象，线程会阻塞在这里
            message = (Message) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        if (message.getMesType().equals(MessageType.RET_RIGHT_FOR_STUDENT)) {
            return message.getRightToUseStudyRoom();
        }
        return null;
    }

    /**
     * 为学生向服务器查询自习室列表
     *
     * @return 自习室列表
     */
    public static List<StudyRoom> studyRoomListForStudent() {
        //发送一个Message，类型GET_STUDY_ROOM_LIST_FOR_STUDENT
        Message message = new Message();
        message.setMesType(MessageType.GET_STUDY_ROOM_LIST_FOR_STUDENT);
        message.setSender(u.getId());

        //发给服务器，应该得到当前线程的Socket对应的ObjectOutputStream对象
        try {
            //通过userId得到对应的线程，从线程里面获取socket对象，再从Socket对象里面获取OutputStream对象
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            objectOutputStream.writeObject(message);
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            //如果服务器没有发送Message对象，线程会阻塞在这里
            message = (Message) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        if (message.getMesType().equals(MessageType.RET_STUDY_ROOM_LIST_FOR_STUDENT)) {
            return message.getStudyRoomList();
        }
        return null;
    }

    //根据userId 和 pwd 到服务器验证该用户是否合法
    public int authenticate(String userId, String pwd) {
        int b = 2;
        //创建User对象
        u.setId(userId);
        u.setPassword(pwd);

        try {
            //连接到服务端，发送u对象
            socket = new Socket(InetAddress.getByName("127.0.0.1"), 9999);//本地运行
            //socket = new Socket(InetAddress.getByName("120.46.202.42"), 9999);//部署到服务器

            //得到 ObjectOutputStream 对象
            ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
            oos.writeObject(u);//发送User对象

            //读取服务器发回来的 Message 对象
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            Message ms = (Message) ois.readObject();

            if (ms.getMesType().equals(MessageType.STUDENT_LOGIN_SUCCEED) || ms.getMesType().equals(MessageType.ADMINISTRATOR_LOGIN_SUCCEED)) {//登录成功
                if (ms.getMesType().equals(MessageType.STUDENT_LOGIN_SUCCEED)) {
                    b = 0;
                } else {
                    b = 1;
                }

            } else {
                //如果登录失败，我们就不可以启动和服务器通信的线程，关闭socket
                socket.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return b;
    }

    //编写方法，退出客户端，并给客户端发送一个message对象，告诉服务端自己要退出系统了
    public void logout() {
        if (socket == null) {
            //System.out.println(u.getId() + " --退出系统--");
            System.exit(0);//结束进程，该客户端的线程也会一并关掉
            return;
        }
        if(isServerClose()){
            return;
        }
        Message message = new Message();
        message.setMesType(MessageType.MESSAGE_CLIENT_EXIT);
        message.setSender(u.getId());//一定要说明自己是哪一个用户

        //发送Message
        try {
            ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
            oos.writeObject(message);
            //System.out.println(u.getId() + " --退出系统--");
            System.exit(0);//结束进程，该客户端的线程也会一并关掉
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 检查网络连接
     * @param target_name IP地址或域名
     * @return
     * @throws IOException
     */
    public static boolean ping(String target_name) {

        boolean reachable = false;
        try {
            InetAddress address = InetAddress.getByName(target_name);
            reachable = address.isReachable(2000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return reachable;
    }

    /**
     * 判断是否断开连接，断开返回true,没有返回false
     * @return
     */
    public static Boolean isServerClose(){
        try{
            socket.sendUrgentData(0xFF);//发送1个字节的紧急数据，默认情况下，服务器端没有开启紧急数据处理，不影响正常通信
            return false;
        }catch(Exception se){
            return true;
        }
    }
}
